Linux Cubed Series 2: Applications/Linux Cubed Series 2 - Applications.iso/editors/emacs/xemacs/xemacs-1.006/xemacs-1/lib/xemacs-19.13/info/ediff.info-2

GNU Info File | 1995-09-01 | 29.7 KB | 585 lines

This is Info file ../info/ediff.info, produced by Makeinfo-1.63 from
the input file ediff.texi.

   This file documents Ediff, a comprehensive visual interface to Unix
`diff' and `patch' utilities.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.


File: ediff.info,  Node: Merging and diff3,  Next: Support for Version Control,  Prev: Patch and Diff Programs,  Up: Customization

Merging and diff3
=================

   Ediff supports 3-way comparison via the functions `ediff-files3' and
`ediff-buffers3'. The interface is the same as for 2-way comparison.
In 3-way comparison and merging, Ediff reports if any two difference
regions are identical. For instance, if the current region in buffer A
is the same as the region in buffer C, then the mode line of buffer A
will display [=diff(C)] and the mode line of buffer C will display
[=diff(A)].

   Merging is done according to the following algorithm.

   If a difference region in one of the buffers, say B, differs from
the ancestor file while the region in the other buffer, A, doesn't,
then the merge buffer, C, gets B's region. Similarly when buffer A's
region differs from the ancestor and B's doesn't.

   If both regions in buffers A and B differ from the ancestor file,
Ediff will choose the region according to the value of the variable
`ediff-default-variant'
     If set to `default-A' then A's region is chosen. If set to
     `default-B' then B's region is chosen. If set to `combined' then
     the region in buffer C will look like this:
          #ifdef NEW  /* variant A */
          difference region from buffer A
          #else  /* variant B */
          difference region from buffer B
          #endif  /* NEW */
     The actual strings that separate the regions copied from bufer A
     and B are controlled by the variable

`ediff-combination-pattern'
     A list of three strings. The first is inserted before the
     difference region of buffer A; the second string goes between the
     regions; the third will trail region B, as shown in the above
     example.

   In addition to the state of the difference, during merging Ediff
displays the state of the merge for each region. If a difference came
from buffer A by default (because both regions A and B were different
from the ancestor and ediff-default-variant was set to `default-A')
then [=diff(A) default-A] is displayed in the mode line.  If the
difference in buffer C came, say, from buffer B because the difference
region in that buffer differs from the ancestor, but the region in
buffer A does not (if merging with an ancestor) then [=diff(B)
prefer-B] is displayed. The indicators default-A/B and prefer-A/B are
inspired by emerge.el and have the same meaning.

   Another indicator of the state of merge is `combined'. It appears
with any difference region in buffer C that was obtained by combining
the difference regions in buffers A and B as explained above.

   In addition to state of merge and difference indicator, in merging
with an ancestor file or buffer, Ediff informs the user when the
current difference region in the (normally invisible) ancestor buffer
is empty via the *AncestorEmpty* indicator. This helps determine if the
changes made to the original in variants A and B represent pure
insertion or deletion of text: if the mode line shows *AncestorEmpty*
and the corresponding region in buffers A or B is not empty, this means
that new text was inserted. If this indicator is not present and the
difference regions in buffers A or B are non-empty, this means that
text was modified. Otherwise, the original text was deleted.

   Although the ancestor buffer is normally invisible, Ediff maintains
difference regions there and advances the current difference region
accordingly. All highlighting of difference regions is provided in the
ancestor buffer, except for the fine differences.  Therefore, if
desired, the user can put the ancestor buffer in a separate frame and
watch it there. However, on a TTY, only one frame can be visible at any
given time, and Ediff doesn't support any single-frame window
configuration where all buffers, including the ancestor buffer, would
be visible. However, the ancestor buffer can be displayed by typing `/'
to the control window. (Type `C-l' to hide it again.)

   Note that the state-of-difference indicators `=diff(A)' and
`=diff(B)' above are not redundant, even in the presence of a
state-of-merge indicator. In fact, the two serve different purposes.
For instance, if the mode line displays [=diff(B) prefer(B)] and you
copy a difference region from buffer A to buffer C then `=diff(B)' will
change to `diff-A' and the mode line will display [=diff(A) prefer-B].
This indicates that the difference region in buffer C is identical to
that in buffer A, but originally buffer C's region came from buffer B.
This is useful to know because the original difference region in buffer
C can be recovered by typing `r', if necessary.

   Ediff never changes the state-of-merge indicator, except in response
to the `!' command (see below), in which case the indicator is lost.
On the other hand, the state-of-difference indicator is changed
automatically by the copying/recovery commands, `a', `b', `r', `+'.

   If Ediff is asked to recompute differences via the command `!', the
information about origins of the regions in the merge buffer (default-A,
prefer-B, or combined) will be lost. This is because recomputing
differences in this case means running diff3 on buffers A, B, and the
merge buffer, not on the ancestor buffer. (It makes no sense to
recompute differences using the ancestor file, since in the merging
mode Ediff assumes that the user did not edit buffers A and B, but he
may have edited buffer C, and these changes are to be preserved.)
Since some difference regions may disappear as a result of editing
buffer C and others may arise, there is generally no simple way to tell
where the various regions in the merge buffer came from.  In fact,
recomputing differences erases all information about the ancestor
buffer, so it will be unhighlighted and disconnected from the current
Ediff session. (However, this doesn't kill the ancestor buffer.)

   In 3-way comparison, Ediff tries to disregard regions that consist
entirely of white space. For instance, if, say, the current region in
buffer A consists of the white space only (or if it is empty), Ediff
will not take it into account for the purpose of computing fine
differences. The result is that Ediff can provide a better visual
information regarding the actual fine differences in the non-white
regions in buffers B and C. Moreover, if the regions in buffers B and C
differ in the white space only, then a message to this effect will be
displayed.

   In the merge mode, the share of the split between window C (the
window displaying the merge-buffer) and the windows displaying buffers
A and B is controlled by the variable
`ediff-merge-window-share'
     The default is 0.5. To make the merge-buffer window smaller,
     reduce this amount. It is not recommended to increase the size of
     the merge-window to more than half the frame (i.e., to increase
     the value of `ediff-merge-window-share') to more than 0.5, since
     it would be hard to see the contents of buffers A and B.

   The user can temporarily shrink the merge window to just one line by
typing `s'. This change is temporary, until Ediff finds a reason to
redraw the screen. Typing `s' again restores the original window size.

   With a positive prefix argument, this command will make the merge
window slightly taller. This change is persistent.  With ``-'' or with
a negative prefix argument, the command `s' makes the merge window
slightly shorter. This change also persistent.

   Ediff lets the user automatically ignore the regions where one of
the buffer's regions is prefered because it disagrees with the
ancestor, while the other buffer agrees with the ancestor. In this
case, Ediff displays only the difference regions where the two buffers,
A and B, both differ from the ancestor file. The variable that controls
this behavior is
`ediff-show-clashes-only'
     The value of this variable can be toggled interactively, by typing
     `$'.  Note that this variable controls only how Ediff chooses the
     next/previous difference to show. The user can still jump directly
     to any difference using the command `j' (with a prefix argument
     specifying the difference number).


File: ediff.info,  Node: Support for Version Control,  Next: Customizing the Mode Line,  Prev: Merging and diff3,  Up: Customization

Support for Version Control
===========================

   Ediff supports version control via the packages `vc.el' and
`rcs.el'. The latter is a package written by Sebastian Kremer
<[e-mail]>, which is available in
     `ftp.cs.buffalo.edu:pub/Emacs/rcs.tar.Z'
     `ftp.uni-koeln.de:/pub/gnu/emacs/rcs.tar.Z'

   To specify which version control package you are using, set the
variable `ediff-version-control-package', e.g.,
     (setq ediff-version-control-package 'rcs)
   A symbol. The default, is `vc'.  *Note*: both packages provide
access to RCS, but only `vc.el' comes standard with Emacs and XEmacs.
`ediff-revision-key'
     A string. For files under revision control, one key can be bound
     to the function `ediff-revision', which runs Ediff comparing
     versions of the current buffer. This is controlled by the above
     variable.  The default is `nil', i.e., Ediff doesn't bind any key
     to run `ediff-revision'.

     If the version control package used is `vc.el', then
     `ediff-revision-key' is bound in a key map accessible through the
     prefix `C-x v', i.e., if you have e.g., `(setq ediff-revision-key
     "=")' in your `~/.emacs' file, then to run `ediff-revision' you
     will have to type `C-x v ='.

     If the version control package is `rcs.el' is used, then the key is
     bound in the global Emacs map, the one available by default. For
     that reason, it is recommended that the key should start with a
     prefix, such as `C-c'.  For instance, if you would like to use
     `C-c E' to run `ediff-revision', put `(setq ediff-revision-key
     "\C-cE")' in your `~/.emacs' file.

     Note: Ediff doesn't bind `ediff-revision-key' when it is first
     loaded. The binding takes effect only when the user invokes
     `ediff-revision'. If you want the binding to take effect right from
     the start, put this in your `~/emacs':
          (setq ediff-revision-key "your-key")
          (require 'ediff)
          (ediff-load-version-control)
     If you want the binding to take effect only after Ediff is first
     loaded into your Emacs, use `ediff-load-hooks':
          (setq ediff-revision-key "your-key")
          (add-hook 'ediff-load-hooks 'ediff-load-version-control)


File: ediff.info,  Node: Customizing the Mode Line,  Next: Miscellaneous,  Prev: Support for Version Control,  Up: Customization

Customizing the Mode Line
=========================

   When Ediff is running, the mode line of Ediff Control Panel buffer
shows the current difference number and the total number of difference
regions in the two files.

   The mode line of the buffers being compared displays the type of the
buffer (`A:', `B:', or `C:') and (usually) the file name. Ediff is
trying to be intelligent in choosing the mode line buffer
identification. In particular, it works well with uniquify.el and
mode-line.el packages (which improve on the default way in which Emacs
displays buffer identification).  If you don't like the way Ediff
changes the mode line, there always is `ediff-prepare-buffer-hooks',
which can be used to modify the mode line.


File: ediff.info,  Node: Miscellaneous,  Next: Notes on Heavy-duty Customization,  Prev: Customizing the Mode Line,  Up: Customization

Miscellaneous
=============

   The following is the last batch of variables that can be customized:
`ediff-split-window-function'
     Controls the way you want the window be split between file-A and
     file-B (and file-C, if applicable).  It defaults to the vertical
     split (`split-window-vertically', but you can set it to
     `split-window-horizontally', if you so wish.

`ediff-merge-split-window-function'
     Controls how windows are split between buffers A and B in the
     merge mode.

`ediff-make-wide-display-function'
     The user can toggle wide/regular display by typing `m'.  In the
     wide display mode, buffers A, B (and C, when applicable) are
     displayed in a single frame that is as wide as the entire
     workstation screen.  This is useful when files are compared
     side-by-side.  By default, the display is widened without changing
     its height. However, the user can set the above variable to
     indicate the name of a function to be called to widen the frame in
     which to display the buffers. See the on-line documentation for
     `ediff-make-wide-display-function' for details. It is also
     recommended to look into the source of the default function
     `ediff-make-wide-display'.

`ediff-use-last-dir'
     Controls the way Ediff presents the default directory when it
     prompts the user for files to compare.  If `nil', Ediff will use
     the default directory of the current buffer when it prompts the
     user for file names.  Otherwise, it will use the directories it
     had previously used for files A, B, or C, respectively.

`ediff-no-emacs-help-in-control-buffer'
     If t, makes `C-h' behave like the `DEL' key, i.e., it will move
     you back to the previous difference rather than invoking help.
     This is useful when, in an xterm window or on a dumb terminal, the
     Backspace key is bound to `C-h' and is positioned more
     conveniently than the `DEL' key.

`ediff-toggle-read-only-function'
     Can be used to change the way Ediff toggles the read-only property
     in its buffers.  By default, Ediff uses `toggle-read-only'. For
     files under version control, Ediff first tries to check the files
     out.

`ediff-keep-variants'
     Default is `t', meaning that the buffers being compared or merged
     will be preserved when Ediff quits. Setting this to `nil' causes
     Ediff to offer the user a chance to delete these buffers (if they
     are not modified).  Supplying a prefix argument to the quit
     command (`q') temporarily reverses the meaning of this variable.
     This is convenient when the user prefers one of the behaviors most
     of the time, but occasionally needs the other behavior.

     Using `ediff-cleanup-hooks', one can make Ediff delete the variants
     unconditionally (e.g., by making `ediff-janitor' into one of these
     hooks).

   Ediff lets you toggle the way windows are split, so you can try
different settings interactively.  *Note*: if buffers A and B (and C,
if applicable) are in different frames, windows are not split,
regardless of the value `ediff-split-window-function'.  Instead, other
windows on these frames are deleted and Ediff starts displaying these
buffers using these frames, one file per frame.  You can switch to the
one-frame mode by hiding one of the buffers A/B/C.

   Note that if Ediff detects that the two buffers it compares are
residing in separate frames, it assumes that the user wants them to be
so displayed and stops splitting windows.  Instead, it will arrange
each buffer to occupy its own frame.

   The user can also swap the windows where buffers are displayed by
typing `~'.


File: ediff.info,  Node: Notes on Heavy-duty Customization,  Prev: Miscellaneous,  Up: Customization

Notes on Heavy-duty Customization
=================================

   Some users need to customize Ediff in rather sophisticated ways,
which requires different defaults for different kinds of files (e.g.,
SGML, etc.).  Ediff supports this kind of customization is several
ways.  First, most customization variables are buffer-local. Those that
aren't are usually accessible from within Ediff Control Panel, so one
can make them local to the panel by calling make-local-variable from
within `ediff-startup-hooks'.  Second, there is now a new optional
(6-th) argument to `ediff-setup', which has the form `( (var-name-1 .
val-1) (var-name-2 . val-2) ...)'.  The function `ediff-setup' will set
the variables on the list to the respective values in the Ediff control
buffer. This is an easy way to throw in custom variables (which usually
should be buffer-local) that can then be tested in various hooks.  Make
sure the variable `ediff-job-name' and `ediff-word-mode' are set
properly in this case, as some things in Ediff depend on this.
Finally, if custom-tailored help messages are desired, Ediff has
`ediff-brief-help-message-custom' and `ediff-long-help-message-custom',
which are local variables that can be set to a function that returns a
string.

   When customizing Ediff, some other variables are useful, although
they are not user-definable. First, it should be kept in mind that most
of the Ediff variables are local to the Ediff control buffer, so this
buffer must be current at the time these variables are accessed. The
control buffer is accessible via the variable `ediff-control-buffer',
which is also local to that buffer.

   Other variables of interest are:
`ediff-buffer-A'
     The first of the data buffers being compared.

`ediff-buffer-B'
     The second of the data buffers being compared.

`ediff-buffer-C'
     In three-way comparisons, this is the third buffer being compared.
     In merging, this is the merge buffer.  In two-way comparison, this
     variable is nil.

`ediff-window-A'
     The window displaying buffer A. If buffer A is not visible, this
     variable is nil or it may be a dead window.

`ediff-window-B'
     The window displaying buffer B.

`ediff-window-C'
     The window displaying buffer C, if any.

`ediff-control-frame'
     A dedicated frame displaying the control buffer, if it exists.  It
     is non-nil only if Ediff uses the multiframe display, i.e., when
     the control buffer is in its own frame.


File: ediff.info,  Node: Credits,  Next: Index,  Prev: Customization,  Up: Top

Credits
*******

   Ediff was written by Michael Kifer <[e-mail]>. It was
inspired by emerge.el written by Dale R. Worley <[e-mail]>.  An
idea due to Boris Goldowsky <[e-mail]> made it possible
to highlight fine differences in Ediff buffers. Alastair Burt
<[e-mail]> ported Ediff to XEmacs, and Eric Freudenthal
<[e-mail]> made it work with VC.

   Many people provided help with bug reports, patches, and advice.
Without them, Ediff would not be nearly as useful as it is now.  Here
is a full list of contributors (I hope I didn't miss anyone):

     Alastair Burt <[e-mail]>, Paul Bibilo
     <[e-mail]>, Kevin Broadey
     <[e-mail]>, Harald Boegeholz
     <[e-mail]>, Jin S. Choi
     <[e-mail]>, Eric Eide <[e-mail]>,
     Kevin Esler <[e-mail]>, Robert Estes
     <[e-mail]>, Eric Freudenthal
     <[e-mail]>, Job Ganzevoort
     <[e-mail]>, Boris Goldowsky
     <[e-mail]>, Allan Gottlieb
     <[e-mail]>, Xiaoli Huang <[e-mail]>,
     Larry Gouge <[e-mail]>, Karl Heuer
     <[e-mail]>, <[e-mail]>,
     <[e-mail]>, David Karr
     <[e-mail]>, Norbert Kiesel
     <[e-mail]>,
     Leigh L Klotz <[e-mail]>, Fritz Knabe
     <[e-mail]>, Heinz Knutzen
     <[e-mail]>,
     Andrew Koenig <[e-mail]>,
     Ken Laprade <[e-mail]>, Will C Lauer <[e-mail]>,
     Richard Levitte <[e-mail]>, Mike Long <[e-mail]>,
     Martin Maechler <[e-mail]>, Simon Marshall
     <[e-mail]>, Richard Mlynarik
     <[e-mail]>, Chris Murphy <[e-mail]>,
     Eyvind Ness <[e-mail]>, Ray Nickson
     <[e-mail]>, Paul Raines <[e-mail]>,
     Benjamin Pierce <[e-mail]>,
     Tibor Polgar <[e-mail]>, C.S. Roberson
     <[e-mail]>, Kevin Rodgers <[e-mail]>,
     Sandy Rutherford <[e-mail]>, Heribert Schuetz
     <[e-mail]>, Andy Scott <[e-mail]>,
     Axel Seibert <[e-mail]>,
     Richard Stallman <[e-mail]>, Richard Stanton
     <[e-mail]>, Ake Stenhoff
     <[e-mail]>, Stig <[e-mail]>, Peter Stout
     <[e-mail]>, Chuck Thompson <[e-mail]>,
     Raymond Toy <[e-mail]>, Ilya Zakharevich
     <[e-mail]>


File: ediff.info,  Node: Index,  Prev: Credits,  Up: Top

Index
*****

* Menu:

* ediff-after-flag-eol:                 Highlighting Difference Regions.
* ediff-after-flag-mol:                 Highlighting Difference Regions.
* ediff-after-setup-control-frame-hooks: Hooks.
* ediff-after-setup-windows-hooks:      Hooks.
* ediff-auto-refine-limit:              Refinement of Difference Regions.
* ediff-auto-refine:                    Refinement of Difference Regions.
* ediff-before-flag-bol:                Highlighting Difference Regions.
* ediff-before-flag-mol:                Highlighting Difference Regions.
* ediff-before-setup-control-frame-hooks: Hooks.
* ediff-before-setup-windows-hooks:     Hooks.
* ediff-brief-help-message-custom:      Notes on Heavy-duty Customization.
* ediff-buffers3:                       Major Entry Points.
* ediff-buffers:                        Major Entry Points.
* ediff-cleanup-hooks:                  Hooks.
* ediff-combination-pattern:            Merging and diff3.
* ediff-control-buffer:                 Quick Help.
* ediff-control-frame-parameters:       Window and Frame Configuration.
* ediff-control-frame-position-function: Window and Frame Configuration.
* ediff-control-frame-upward-shift:     Window and Frame Configuration.
* ediff-current-diff-face-A:            Highlighting Difference Regions.
* ediff-current-diff-face-B:            Highlighting Difference Regions.
* ediff-current-diff-face-C:            Highlighting Difference Regions.
* ediff-custom-diff-options:            Patch and Diff Programs.
* ediff-custom-diff-program:            Patch and Diff Programs.
* ediff-default-variant:                Merging and diff3.
* ediff-diff-options:                   Patch and Diff Programs.
* ediff-diff-program <1>:               Refinement of Difference Regions.
* ediff-diff-program:                   Patch and Diff Programs.
* ediff-diff3-options:                  Patch and Diff Programs.
* ediff-diff3-program:                  Patch and Diff Programs.
* ediff-directories3:                   Major Entry Points.
* ediff-directories:                    Major Entry Points.
* ediff-directory-revisions:            Major Entry Points.
* ediff-display-help-hooks:             Hooks.
* ediff-even-diff-face-A:               Highlighting Difference Regions.
* ediff-even-diff-face-B:               Highlighting Difference Regions.
* ediff-even-diff-face-C:               Highlighting Difference Regions.
* ediff-files3:                         Major Entry Points.
* ediff-files:                          Major Entry Points.
* ediff-fine-diff-face-A:               Highlighting Difference Regions.
* ediff-fine-diff-face-B:               Highlighting Difference Regions.
* ediff-fine-diff-face-C:               Highlighting Difference Regions.
* ediff-forward-word-function:          Refinement of Difference Regions.
* ediff-forward-word:                   Refinement of Difference Regions.
* ediff-help-message:                   Quick Help.
* ediff-highlight-all-diffs:            Highlighting Difference Regions.
* ediff-ignore-similar-regions:         Selective Browsing.
* ediff-janitor:                        Hooks.
* ediff-job-name:                       Notes on Heavy-duty Customization.
* ediff-keep-variants:                  Miscellaneous.
* ediff-keymap-setup-hooks:             Hooks.
* ediff-load-hooks:                     Hooks.
* ediff-long-help-message-custom:       Notes on Heavy-duty Customization.
* ediff-make-frame-position:            Window and Frame Configuration.
* ediff-make-wide-display-function:     Miscellaneous.
* ediff-merge-buffers-with-ancestor:    Major Entry Points.
* ediff-merge-buffers:                  Major Entry Points.
* ediff-merge-directories-with-ancestor: Major Entry Points.
* ediff-merge-directories:              Major Entry Points.
* ediff-merge-directory-revisions-with-ancestor: Major Entry Points.
* ediff-merge-directory-revisions:      Major Entry Points.
* ediff-merge-files-with-ancestor:      Major Entry Points.
* ediff-merge-files:                    Major Entry Points.
* ediff-merge-revisions-with-ancestor:  Major Entry Points.
* ediff-merge-revisions:                Major Entry Points.
* ediff-merge-split-window-function:    Miscellaneous.
* ediff-merge-window-share:             Merging and diff3.
* ediff-merge-with-ancestor:            Major Entry Points.
* ediff-merge:                          Major Entry Points.
* ediff-mode-hooks:                     Hooks.
* ediff-narrow-control-frame-leftward-shift: Window and Frame Configuration.
* ediff-no-emacs-help-in-control-buffer: Miscellaneous.
* ediff-odd-diff-face-A:                Highlighting Difference Regions.
* ediff-odd-diff-face-B:                Highlighting Difference Regions.
* ediff-odd-diff-face-C:                Highlighting Difference Regions.
* ediff-patch-buffer:                   Major Entry Points.
* ediff-patch-file:                     Major Entry Points.
* ediff-patch-options:                  Patch and Diff Programs.
* ediff-patch-program:                  Patch and Diff Programs.
* ediff-prefer-iconified-control-frame: Window and Frame Configuration.
* ediff-prefer-long-help-message <1>:   Quick Help.
* ediff-prefer-long-help-message:       Window and Frame Configuration.
* ediff-prepare-buffer-hooks <1>:       Customizing the Mode Line.
* ediff-prepare-buffer-hooks:           Hooks.
* ediff-profile:                        Commands.
* ediff-quit-hooks:                     Hooks.
* ediff-regions-linewise <1>:           Narrowing.
* ediff-regions-linewise:               Major Entry Points.
* ediff-regions-wordwise <1>:           Narrowing.
* ediff-regions-wordwise:               Major Entry Points.
* ediff-registry-setup-hooks:           Hooks.
* ediff-revert-buffers-then-recompute-diffs: Commands.
* ediff-revision-key:                   Support for Version Control.
* ediff-revision:                       Major Entry Points.
* ediff-save-buffer:                    Patch and Diff Programs.
* ediff-select-hooks:                   Hooks.
* ediff-session-group-setup-hooks:      Hooks.
* ediff-setup-windows-multiframe:       Window and Frame Configuration.
* ediff-setup-windows-plain:            Window and Frame Configuration.
* ediff-setup-windows:                  Window and Frame Configuration.
* ediff-setup:                          Notes on Heavy-duty Customization.
* ediff-show-clashes-only:              Merging and diff3.
* ediff-split-window-function:          Miscellaneous.
* ediff-start-narrowed:                 Narrowing.
* ediff-startup-hooks <1>:              Quick Help.
* ediff-startup-hooks <1>:              Notes on Heavy-duty Customization.
* ediff-startup-hooks:                  Hooks.
* ediff-suspend-hooks:                  Hooks.
* ediff-toggle-multiframe <1>:          Commands.
* ediff-toggle-multiframe:              Window and Frame Configuration.
* ediff-toggle-read-only-function:      Miscellaneous.
* ediff-unselect-hooks:                 Hooks.
* ediff-use-last-dir <1>:               Miscellaneous.
* ediff-use-last-dir:                   Major Entry Points.
* ediff-version-control-package:        Support for Version Control.
* ediff-wide-control-frame-rightward-shift: Window and Frame Configuration.
* ediff-window-setup-function:          Window and Frame Configuration.
* ediff-windows-linewise <1>:           Major Entry Points.
* ediff-windows-linewise:               Narrowing.
* ediff-windows-wordwise <1>:           Narrowing.
* ediff-windows-wordwise:               Major Entry Points.
* ediff-word-1:                         Refinement of Difference Regions.
* ediff-word-2:                         Refinement of Difference Regions.
* ediff-word-3:                         Refinement of Difference Regions.
* ediff-word-4:                         Refinement of Difference Regions.
* ediff-word-mode:                      Notes on Heavy-duty Customization.
* ediff3:                               Major Entry Points.
* ediff:                                Major Entry Points.
* edir-merge-revisions-with-ancestor:   Major Entry Points.
* edir-merge-revisions:                 Major Entry Points.
* edir-revisions:                       Major Entry Points.
* edirs-merge-with-ancestor:            Major Entry Points.
* edirs-merge:                          Major Entry Points.
* edirs3:                               Major Entry Points.
* edirs:                                Major Entry Points.
* epatch-buffer:                        Major Entry Points.
* epatch:                               Major Entry Points.
* split-window-horizontally:            Miscellaneous.
* split-window-vertically:              Miscellaneous.
* mode-line.el:                         Customizing the Mode Line.
* rcs.el:                               Support for Version Control.
* uniquify.el:                          Customizing the Mode Line.
* vc.el:                                Support for Version Control.
* Comparing files and buffers:          Introduction.
* ediff-show-registry:                  Commands.
* eregistry:                            Commands.
* Finding differences:                  Introduction.
* Merging files and buffers:            Introduction.
* Multi-file patches:                   Session Groups.
* Patching files and buffers:           Introduction.